使用 passport 做身份认证

我们实现过登录和身份认证，登录的时候基于用户名密码，后续基于 jwt。

像这种身份认证逻辑其实很通用，每个项目都会有，自然可以抽取成一个库。

先不看第三方库是怎么做的，思考下，如果让你做一个身份认证的库，你会怎么设计呢？

首先，身份认证有多种方式，比如用户名密码、jwt、google 登录、github 登录等。

这多种方式都可以实现身份认证，那我们就可以用策略模式把它们封装成一个个策略类（Strategy）。

简单看下策略模式的介绍：

其实它就是实现了一个接口的多个类，这些类可以相互替换。

这里我们就可以用策略模式来做。

然后每个策略类里封装什么呢？

其实不同的认证方式虽然逻辑不同，但做的事情很类似：

• 用户名密码登录就是从 request 的 body 里取出 username、password 来认证。
• jwt 是从 request 的 Authorization 的 header 取出 token 来认证。

不同策略都会从 request 中取出一些东西来认证，如果认证就在 request.user 上存放认证后的 user 信息，这就是它们的共同点。

比如身份认证库 passport 的两种策略：

可以看到，不管是用户名密码的身份认证，还是 jwt 的身份认证，都会从 request 的 body 或者 header 中取出一些信息来，然后认证通过之后返回 user 的信息，passport 会设置到 request.user 上。

这个封装思路你理解了，那 passport 这个库也就差不多掌握了。

然后我们在 nest 里用一下 passport 这个库：

nest new nest-passport

进入项目，安装 passport：

npm install --save @nestjs/passport passport

然后我们首先实现用户名密码的认证。

这用到 passport-local 的策略，安装下：

npm install --save passport-local
npm install --save-dev @types/passport-local

然后创建一个认证模块：

nest g module auth
nest g service auth --no-spec

添加用户名密码认证的策略：

import { Strategy } from "passport-local";
import { PassportStrategy } from "@nestjs/passport";
import { Injectable, UnauthorizedException } from "@nestjs/common";
import { AuthService } from "./auth.service";

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
    constructor(private authService: AuthService) {
        super();
    }

    async validate(username: string, password: string) {
        const user = await this.authService.validateUser(username, password);
        return user;
    }
}

在 AuthModule 引入下：

这个 LocalStrategy 的逻辑就像前面分析的：

从 reqeust 的 body 中取出 username 和 password 交给你去认证，认证过了之后返回 user，它会把 user 放到 request.user 上，如果认证不通过，就抛异常，由 exception filter 处理。

我们在 AuthService 里实现这个 validateUser 方法：

import { Inject, Injectable, UnauthorizedException } from "@nestjs/common";
import { UserService } from "src/user/user.service";

@Injectable()
export class AuthService {
    @Inject()
    private userService: UserService;

    async validateUser(username: string, pass: string) {
        const user = await this.userService.findOne(username);

        if (!user) {
            throw new UnauthorizedException("用户不存在");
        }
        if (user.password !== pass) {
            throw new UnauthorizedException("密码错误");
        }

        const { password, ...result } = user;
        return result;
    }
}

AuthService 里根据用户名密码去校验，但是查询用户的逻辑应该在 UserModule 里，我们写一下：

nest g module user
nest g service user --no-spec

UserService：

import { Injectable } from "@nestjs/common";

@Injectable()
export class UserService {
    private readonly users = [
        {
            userId: 1,
            username: "神说要有光",
            password: "guang",
        },
        {
            userId: 2,
            username: "东东东",
            password: "dong",
        },
    ];

    async findOne(username: string) {
        return this.users.find((user) => user.username === username);
    }
}

在 UserModule 里导出 UserService：

然后在 AuthModule 里引入下：

这样，passport 的流程就完成了，它会从 request 中取出 body 的 username 和 password 交给我们的 validate 方法去认证，认证完会返回 user 信息，放到 request.user 上。

那怎么应用这个策略呢？

很明显，这里适合用 Guard。

@nestjs/passport 已经做了封装了。

我们在 AppController 里加个 login 方法：

import { Controller, Get, Post, Req, UseGuards } from "@nestjs/common";
import { AppService } from "./app.service";
import { AuthGuard } from "@nestjs/passport";
import { Request } from "express";

@Controller()
export class AppController {
    constructor(private readonly appService: AppService) {}

    @UseGuards(AuthGuard("local"))
    @Post("login")
    async login(@Req() req: Request) {
        console.log(req.user);
        return req.user;
    }

    @Get()
    getHello(): string {
        return this.appService.getHello();
    }
}

把服务跑起来：

npm run start:dev

postman 里测试下：

这样，基于 passport 的登录就完成了。

不用我们自己从 request 取 body 中的 username 和 password，也不用我们把查询结果放到 request.user 上，更不用自己实现 Guard。

确实减少了不少代码。

接下来继续做 JWT 的认证：

登录的时候通过用户名、密码认证，这时候登录认证成功会返回 jwt，然后再次访问会在 Authorization 的 header 携带 jwt，然后通过 header 的 jwt 来认证。

这是一种新的认证方式，需要用新的策略。

我们首先在登录成功之后返回 jwt。

安装用到的包：

npm install --save @nestjs/jwt

在 AppModule 里引入下：

JwtModule.register({
    secret: "guang"
}),

然后在 AppController 里 login 接口返回 jwt 的 token：

这里需要扩展下 express 的 request.user 的类型。

import { Controller, Get, Inject, Post, Req, UseGuards } from "@nestjs/common";
import { AppService } from "./app.service";
import { AuthGuard } from "@nestjs/passport";
import { Request } from "express";
import { JwtService } from "@nestjs/jwt";

interface JwtUserData {
    userId: number;
    username: string;
}

declare module "express" {
    interface Request {
        user: JwtUserData;
    }
}

@Controller()
export class AppController {
    constructor(private readonly appService: AppService) {}

    @Inject()
    jwtService: JwtService;

    @UseGuards(AuthGuard("local"))
    @Post("login")
    async login(@Req() req: Request) {
        console.log(req.user);
        const token = this.jwtService.sign(
            {
                userId: req.user.userId,
                username: req.user.username,
            },
            {
                expiresIn: "0.5h",
            }
        );

        return {
            token,
        };
    }

    @Get()
    getHello(): string {
        return this.appService.getHello();
    }
}

试一下：

这样，登录之后返回 jwt 就完成了。

然后添加 jwt.strategy.ts

import { ExtractJwt, Strategy } from "passport-jwt";
import { PassportStrategy } from "@nestjs/passport";
import { Injectable } from "@nestjs/common";

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
    constructor() {
        super({
            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
            ignoreExpiration: false,
            secretOrKey: "guang",
        });
    }

    async validate(payload: any) {
        return { userId: payload.userId, username: payload.username };
    }
}

指定从 request 的 header 里提取 token，然后取出 payload 之后会传入 validate 方法做验证，返回的值同样会设置到 request.user。

安装用到的包：

npm install --save passport-jwt
npm install --save-dev @types/passport-jwt

在 AuthModule 引入下：

在 AppController 里添加一个新的需要登录认证的接口：

@UseGuards(AuthGuard('jwt'))
@Get("list")
list(@Req() req: Request) {
    console.log(req.user);
    return ['111', '222', '333', '444', '555']
}

首先不带 token 访问下：

然后通过 Authorization 的 header 带上 Bearer xxx 的 token 访问下：

可以看到，jwt 的认证生效了。

对比下用 passport 和不用有啥区别呢？

不用我们自己从 request 的 header 里取 token 了，也不用自己从 token 提取的信息放到 request.user 里了，也不用自己写 Guard 了。

确实方便了很多。

这样，我们就用了两个 local 和 jwt 两个策略了。

其他策略也是类似的流程，从 request 取一些信息，交给 validate 方法去验证，返回 user 放到 request.user 里。

那如果我想对 Guard 的流程做一些扩展呢？

比如 jwt 的 Guard，现在需要在每个 controller 上手动应用，我想通过一个 @IsPublic 的装饰器来标识，如果有 @IsPublic 的装饰器就不需要身份认证，否则就需要。

这就需要继承 AuthGuard('jwt') 做一些扩展了：

首先，生成一个自定义装饰器：

nest g decorator is-public --flat --no-spec

它的实现就是给被装饰对象添加一个 metadata：

import { SetMetadata } from "@nestjs/common";

export const IS_PUBLIC_KEY = "isPublic";
export const IsPublic = () => SetMetadata(IS_PUBLIC_KEY, true);

然后在 AppController 里加几个路由：

@IsPublic()
@Get('aaa')
aaa() {
    return 'aaa';
}

@Get('bbb')
bbb() {
    return 'bbb';
}

aaa 是 public 的，不需要身份认证，而 bbb 需要。

这时就需要对 AuthGuard('jwt') 做下扩展。

新建 auth/JwtAuthGuard.ts

import { ExecutionContext, Injectable } from "@nestjs/common";
import { Reflector } from "@nestjs/core";
import { AuthGuard } from "@nestjs/passport";
import { IS_PUBLIC_KEY } from "src/is-public.decorator";

@Injectable()
export class JwtAuthGuard extends AuthGuard("jwt") {
    constructor(private reflector: Reflector) {
        super();
    }

    canActivate(context: ExecutionContext) {
        const isPublic = this.reflector.getAllAndOverride<boolean>(
            IS_PUBLIC_KEY,
            [context.getHandler(), context.getClass()]
        );

        if (isPublic) {
            return true;
        }
        return super.canActivate(context);
    }
}

实现就是从目标 controller、handler 上取 public 的 meatadata，如果有就直接放行，否则才做认证。

然后在 AppModule 里注册为全局 Guard：

{
    provide: APP_GUARD,
    useClass: JwtAuthGuard
}

测试下：

没啥问题，这样，对 AuthGuard('jwt') 的扩展就完成了。

案例代码上传了小册仓库

总结

之前我们都是自己实现身份认证，比如基于用户名密码的认证，基于 jwt 的认证，今天我们基于 passport 库来实现了一遍。

passport 把不同的认证逻辑封装成了不同 Strategy，每个 Stategy 都有 validate 方法来验证。

每个 Strategy 都是从 request 取出一些东西，交给 validate 方法验证，validate 方法返回 user 信息，自动放到 request.user 上。

并且 @nestjs/passport 提供了 Guard 可以直接用，如果你想扩展，继承 AuthGuard('xxx') 然后重写下 canActivate 方法就好了。

细想一下，你做各种认证的时候，是不是也在做同样的事情呢？

那既然每次都是做这些事情，那为啥不用 passport 库来简化呢？